class Promise{
    // 构造函数
    constructor(executor){
        this.PromiseState = 'pending';
        this.PromiseResult = null;
        // 声明属性
        // this.callback = {};
        this.callbacks=[];
        // 保存实例对象的this的值
        const self = this;
     
        function resolve(data){
            if(self.PromiseState!=='pending'){
                return;
            };
            // 1、修改对象状态(PromiseState)
            self.PromiseState = 'fullfilled';
            // 2、设置对象结果值(PromiseResult)
            self.PromiseResult= data;
    
            // 调用成功的回调函数
            // if(self.callback.onResolved){
            //     self.callback.onResolved(data)
            // }
            setTimeout(()=>{
                self.callbacks.forEach(item=>{
                    item.onResolved(data);
                })
            })
            
        }
        function reject(data){
            if(self.PromiseState!=='pending'){
                return;
            };
            self.PromiseState = 'rejected';
            self.PromiseResult = data;
    
            // 调用成功的回调函数
            // if(self.callback.onRejected){
            //     self.callback.onRejected(data)
            // }
            setTimeout(()=>{
                self.callbacks.forEach(item=>{
                    item.onRejected(data);
                })
            })
        }
        try{
            // 同步调用执行器函数
            executor(resolve,reject);
        }catch(e){
            // 修改promise状态为失败
            reject(e);
    
        }
    }
    // then方法
    then(onResolved,onRejected){
        const self = this;
        // 判断回调函数参数
        if(typeof onRejected !== 'function'){
            onRejected=reason=>{
                throw reason;
            }
        }
        if(typeof onResolved!=='function'){
            onResolved = value=>value;
        }
        return new Promise((resolve,reject)=>{
            function callback (type){
                try{
                    let result = type(self.PromiseResult);
                    if(result instanceof Promise){
                        result.then(v=>{
                            resolve(v);
                        },r=>{
                            reject(r);
                        })
                    }else{
                        resolve(result);
                    }   
                }catch(e){
                    reject(e);
                }
            }
            if(this.PromiseState==='fullfilled'){
                // try{
                //     let result = onResolved(this.PromiseResult);
                //     if(result instanceof Promise){
                //         result.then(v=>{
                //             resolve(v);
                //         },r=>{
                //             reject(r);
                //         })
                //     }else{
                //         resolve(result);
                //     }   
                // }catch(e){
                //     reject(e);
                // }
                setTimeout(()=>{
                    callback(onResolved);
                });     
            };
            if(this.PromiseState==='rejected'){
                // try{
                //     let result = onRejected(this.PromiseResult);
                //     if(result instanceof Promise){
                //         result.then(v=>{
                //             resolve(v)
                //         },r=>{
                //             reject(r)
                //         })
                //     }else{
                //         resolve(result)
                //     }
                // }catch(e){
                //     reject(e)
                // }  
                
                setTimeout(()=>{
                    callback(onRejected);
                })
                
            };
            if(this.PromiseState==='pending'){
                // 保存回调函数
                this.callbacks.push({
                    onResolved : function(){
                        // try{
                        //     // 执行成功回调函数
                        //     // console.log('success');
                        //     let result = onResolved(self.PromiseResult);
                        //     // 判断
                        //     if(result instanceof Promise){
                        //         result.then(v=>{
                        //             console.log(v)
                        //         },r=>{
                        //             console.log(r)
                        //         })
                        //     }else{
                        //         console.log(result)
                        //     }
                        // }catch(e){
                        //     reject(e);
                        // }
                        callback(onResolved);
                    },
                    
                    onRejected:function(){
                        // try{
                        //     let result  = onRejected(self.PromiseResult);
                        //     if(result instanceof Promise){
                        //         result.then(v=>{
                        //             console.log(v)
                        //         },r=>{
                        //             console.log(r)
                        //         })
                        //     }else{
                        //         console.log(result)
                        //     }
                        // }catch(e){
                        //     reject(e);
                        // }     
                        callback(onRejected);
                     }
                   }                   
                ) 
            }
        })
    }
    // catch 方法
    catch(onRejected){
        return this.then(undefined,onRejected);
    }
    // resolve方法
    static resolve(value){
        return new Promise((resolve,reject)=>{
            if(value instanceof Promise){
                value.then(v=>{
                    resolve(v);
                },r=>{
                    reject(r);
                })
            }else{
                resolve(value);
            }
        })
    }
    // reject方法
    static reject(reason){
        return new Promise((resolve,reject)=>{
            reject(reason);
        })
    }
    // 添加all方法
    static all(promises){
        let count = 0;
        let arr = [];
    
        for(let i=0;i<promises.length;i++){
            promises[i].then(v=>{
                count++;
                // arr.push(v); 顺序不确定
                arr[i] = v;
                if(count===promises.length){
                    resolve(arr);
                }
            },r=>{
                reject(r);
            })
        }   
    }
    // 添加race方法
    static race(promises){
        return new Promise((resolve,reject)=>{
            for(let i=0;i<promises.length;i++){
                promises[i].then(v=>{
                    resolve(v)
                },r=>{
                    reject(r)
                })
            }
        })
    }

}


// function Promise(executor){

// }

// // 添加then方法
// Promise.prototype.then= function (onResolved,onRejected){
    
// // onRejected : function(){
//                     // console.log('error')
//                     // onRejected(self.PromiseResult)
// // this.callbacks.push(
//             //     {
//             //         onResolved,
//             //         onRejected
//             //     }               
//             // )

// // this.callback={
// //     onResolved,
// //     onRejected
// // }
// }

// // 添加catch方法
// Promise.prototype.catch = function(onRejected){
    
// }

// // 添加resolve方法
// Promise.resolve = function(value){
    
// }

// // 添加reject方法
// Promise.reject=function(reason){
    
// }


// // 添加all方法
// Promise.all = function(promises){

// }

// // 添加race方法
// Promise.race = function(promises){
    
// }